cluFlock

Control of lock of the file using the 'flock' functions.

Capabilities

1. Convenient and transparent trait of a call of locks.
2. Automatic unlocking of lock.

Locks

1. ExclusiveLock - Only one process can retain exclusive lock of the file.
2. SharedLock - Can retain the general lock on the given file more than one process.

Use

1. LockFile

    extern crate cluFlock;
   
    use cluFlock::Flock;
    use std::fs::File;
   
    fn main() {
    	let file = File::create("/tmp/1").unwrap();
   
    	let lock = file.exclusive_lock();
    	//Only one process can retain exclusive lock of the file.
   
    	println!("{:?}", lock);
   
    	drop(lock);
    }
   

2. TryLockFile

    extern crate cluFlock;
   
    use cluFlock::Flock;
    use std::fs::File;
    use std::time::Duration;
   
    fn main() {
    	let file = match File::create("/tmp/ulin.lock") {
    		Ok(a) => a,
    		Err(e) => panic!("Panic, err create file {:?}", e),
    	};
   
    	println!("Try_Exclusive_Lock, {:?}", file);
    	let lock = match file.try_exclusive_lock() {
    		//Success, we blocked the file.
    		Ok(Some(lock)) => {
    			println!("File {:?} successfully locked.", file);
    			lock
    		},
   
    		//File already locked.
    		Ok(None) => {
    			println!("File {:?} already locked.", file);
   
    			println!("!Exclusive_Lock, {:?}", file);
    			//Lock the current thread to such an extent until your file is unlocked.
    			file.exclusive_lock().unwrap()
    		},
   
    		Err(e) => panic!("Panic, err lock file {:?}", e)
   
    	};
   
    	println!("Sleep, 5s");
    	::std::thread::sleep(Duration::from_secs(5));
   
    	println!("Unlock, {:?}", file);
    	drop(lock);
    }
   

3. FileLock (BufLockFile + try_lock)

    extern crate cluFlock;
   
    use std::io::ErrorKind::AlreadyExists;
    use cluFlock::ExclusiveLock;
    use cluFlock::Flock;
    use std::path::Path;
    use std::fs;
    use std::io;
    use std::io::Error;
    use std::io::ErrorKind;
    use std::fs::OpenOptions;
   
    #[derive(Debug)]
    pub struct MyLockFile<'a>(ExclusiveLock, Option<&'a Path>);
   
    impl<'a> MyLockFile<'a> {
    	pub fn new(p: &'a Path) -> Result<Self, io::Error> {
    		let (lock, path) = match OpenOptions::new().write(true).create_new(true).open(p) {
    			Ok(file) => (file.file_exclusive_lock()?, Some(p)),
    			Err(ref e) if e.kind() == AlreadyExists => {
    				let f = OpenOptions::new().read(true).open(p)?; 
   
    				match f.try_file_exclusive_lock() {
    					Ok(Some(lock)) => (lock, None),
    					Ok(None) => return Err(Error::new(ErrorKind::Other, "the file is already locked")),
    					Err(e) => return Err(e),
    				}
    			},
    			Err(e) => return Err(e),
    		};
   
    		Ok( MyLockFile(lock, path) )
    	}
    }
   
    impl<'a> Drop for MyLockFile<'a> {
    	fn drop(&mut self) {
    		if let Some(path) = self.1 {
    			let _e = fs::remove_file(path);
    		}
    	}
    }
   
   
    pub fn main() -> Result<(), io::Error> {
    	let path = Path::new("/tmp/flock.lock");
    	println!("LockFile {:?}", path);
    	let lock_file = MyLockFile::new(path)?;
   
    	println!("OK! FileLock {:?}", lock_file);
    	for a in 0..4 {
    		println!("Sleep {}", a);
    		::std::thread::sleep(::std::time::Duration::from_secs(1));
    	}
   
    	drop(lock_file);
   
    	Ok( () )
    }
   

License

Copyright 2018 #UlinProject Денис Котляров

Licensed under the Apache License, Version 2.0